1,158 research outputs found
Generic Programming with Extensible Data Types; Or, Making Ad Hoc Extensible Data Types Less Ad Hoc
We present a novel approach to generic programming over extensible data
types. Row types capture the structure of records and variants, and can be used
to express record and variant subtyping, record extension, and modular
composition of case branches. We extend row typing to capture generic
programming over rows themselves, capturing patterns including lifting
operations to records and variations from their component types, and the
duality between cases blocks over variants and records of labeled functions,
without placing specific requirements on the fields or constructors present in
the records and variants. We formalize our approach in System R{\omega}, an
extension of F{\omega} with row types, and give a denotational semantics for
(stratified) R{\omega} in Agda.Comment: To appear at: International Conference on Functional Programming 2023
Corrected citations from previous versio
Constrained Type Families
We present an approach to support partiality in type-level computation
without compromising expressiveness or type safety. Existing frameworks for
type-level computation either require totality or implicitly assume it. For
example, type families in Haskell provide a powerful, modular means of defining
type-level computation. However, their current design implicitly assumes that
type families are total, introducing nonsensical types and significantly
complicating the metatheory of type families and their extensions. We propose
an alternative design, using qualified types to pair type-level computations
with predicates that capture their domains. Our approach naturally captures the
intuitive partiality of type families, simplifying their metatheory. As
evidence, we present the first complete proof of consistency for a language
with closed type families.Comment: Originally presented at ICFP 2017; extended editio
A simple semantics for Haskell overloading
As originally proposed, type classes provide overloading and ad-hoc
definition, but can still be understood (and implemented) in terms of strictly
parametric calculi. This is not true of subsequent extensions of type classes.
Functional dependencies and equality constraints allow the satisfiability of
predicates to refine typing; this means that the interpretations of equivalent
qualified types may not be interconvertible. Overlapping instances and instance
chains allow predicates to be satisfied without determining the implementations
of their associated class methods, introducing truly non-parametric behavior.
We propose a new approach to the semantics of type classes, interpreting
polymorphic expressions by the behavior of each of their ground instances, but
without requiring that those behaviors be parametrically determined. We argue
that this approach both matches the intuitive meanings of qualified types and
accurately models the behavior of programsComment: Originally presented at Haskell 201
Mixed Messages: Measuring Conformance and Non-Interference in TypeScript (Artifact)
In the paper Mixed Messages: Measuring Conformance and Non-Interference in TypeScript we present our experiences of evaluating gradual typing using our tool TypeScript TPD. The tool, based on the polymorphic blame calculus, monitors JavaScript libraries and TypeScript clients against the corresponding TypeScript definition. Our experiments yield two conclusions. First, TypeScript definitions are prone to error. Second, there are serious technical concerns with the use of the JavaScript proxy mechanism for enforcing contracts. This artifact includes all the libraries we tested, their definition files, and the source code of our tool. From this, all libraries can be wrapped and tested to reproduce the log data that formed our conclusion. All conformance errors and examples of interference are documented, and can be verified against the generated logs
Partial type constructors: Or, making ad hoc datatypes less ad hoc
This work is licensed under a Creative Commons Attribution 4.0 International License.Functional programming languages assume that type constructors are total. Yet functional programmers know better: counterexamples range from container types that make limiting assumptions about their contents (e.g., requiring computable equality or ordering functions) to type families with defining equations only over certain choices of arguments. We present a language design and formal theory of partial type constructors, capturing the domains of type constructors using qualified types. Our design is both simple and expressive: we support partial datatypes as first-class citizens (including as instances of parametric abstractions, such as the Haskell Functor and Monad classes), and show a simple type elaboration algorithm that avoids placing undue annotation burden on programmers. We show that our type system rejects ill-defined types and can be compiled to a semantic model based on System F. Finally, we have conducted an experimental analysis of a body of Haskell code, using a proof-of-concept implementation of our system; while there are cases where our system requires additional annotations, these cases are rarely encountered in practical Haskell code
Towards Races in Linear Logic
Part 1: Computational ModelsInternational audienceProcess calculi based in logic, such as DILL and CP, provide a foundation for deadlock-free concurrent programming, but exclude non-determinism and races. HCP is a reformulation of CP which addresses a fundamental shortcoming: the fundamental operator for parallel composition from the -calculus does not correspond to any rule of linear logic, and therefore not to any term construct in CP. We introduce HCP, which extends HCP with a novel account of non-determinism. Our approach draws on bounded linear logic to provide a strongly-typed account of standard process calculus expressions of non-determinism. We show that our extension is expressive enough to capture many uses of non-determinism in untyped calculi, such as non-deterministic choice, while preserving HCP ’s meta-theoretic properties, including deadlock freedom
Mixed Messages: Measuring Conformance and Non-Interference in TypeScript
TypeScript participates in the recent trend among programming
languages to support gradual typing. The DefinitelyTyped Repository
for TypeScript supplies type definitions for over 2000 popular
JavaScript libraries. However, there is no guarantee that
implementations conform to their corresponding declarations.
We present a practical evaluation of gradual typing for TypeScript.
We have developed a tool for use with TypeScript, based on the
polymorphic blame calculus, for monitoring JavaScript libraries and
TypeScript clients against the TypeScript definition. We apply our
tool, TypeScript TPD, to those libraries in the DefinitelyTyped
Repository which had adequate test code to use. Of the 122 libraries
we checked, 62 had cases where either the library or its tests
failed to conform to the declaration.
Gradual typing should satisfy non-interference. Monitoring a program
should never change its behaviour, except to raise a type error
should a value not conform to its declared type. However, our
experience also suggests serious technical concerns with the use of
the JavaScript proxy mechanism for enforcing contracts. Of the 122
libraries we checked, 22 had cases where the library or its tests
violated non-interference
- …